﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Web;
using RC.ControlAcceso.ObjetosNegocio;
using System.Data;
using System.Data.SqlClient;
using Microsoft.ApplicationBlocks.Data;
using System.Configuration;
using System.IO;
using System.Drawing;
using System.Drawing.Printing;
using System.Threading;
using BusinessLayer;
using RC.ControlAcceso.ObjetosNegocio;

/// <summary>
/// Summary description for WatchDogImprimirTickets
/// </summary>
public class Hilos
{   
    public static void IniciarHilos()
    {
        IniciarHiloSincronizacionConDelfosEmpleados(); // Personal en Chrono
        IniciarHiloSincronizacionConDelfosUsuariosDelSistema();
        IniciarHiloImportacionDeMarcas(); //importa marcas desde la tabla informeUsuario
    }

    #region Métodos para sincronización con Delfos  de usuarios del sistema
    private static Thread _sincronizarConDelfosUsuarios;
    static volatile bool _detenerHiloSincronizacionConDelfosUsuarios = false;
    /// <summary>
    /// Inicia el proceso de sincronización con Delfos
    /// </summary>
    private static void IniciarHiloSincronizacionConDelfosUsuariosDelSistema()
    {
        if (CA2Parametros.EsModuloDeDelfos == false)
            return;

        if (CA2Parametros.SincronizacionDelfosActiva == false)
            return;

        // si esta activo el hilo, lo detengo si esta
        DetenerHilosincronizacionConDelfosUsuariosDelSistema();

        _sincronizarConDelfosUsuarios = new Thread(SincronizarUsuariosDelSistema);
        _sincronizarConDelfosUsuarios.Start();
        _detenerHiloSincronizacionConDelfosUsuarios = false;
    }
    private static void SincronizarUsuariosDelSistema()
    {
        do
        {
            ForzarSincronizarUsuariosDelSistema();

            Thread.Sleep(CA2Parametros.MinutosEntreSincronizacionesDeUsuariosConDelfos * 60 * 1000);

        } while (_detenerHiloSincronizacionConDelfosUsuarios == false);
    }
    private static void ForzarSincronizarUsuariosDelSistema()
    {
        try
        {
            WSDelfos.WebServiceDelfos ws = new WSDelfos.WebServiceDelfos();

            WSDelfos.Chrono_Usuario[] _usuarios = ws.getUsuariosALL(CA2Parametros.ClaveWebServiceDelfos);

            //List<Chrono_Usuario> _usuarios = new List<Chrono_Usuario>();

            // _usuarios = ObtenerLoteDePruebaUsuarios;
            if ((_usuarios != null)
                && (_usuarios.Length > 0))
            {
                foreach (WSDelfos.Chrono_Usuario _usuario in _usuarios)
                    ActualizarUsuario(_usuario);
            }
        }
        catch(Exception e)
        {
        }
        
    }
    /// <summary>
    /// Detiene el hilo de impresion de tickets
    /// </summary>
    public static void DetenerHilosincronizacionConDelfosUsuariosDelSistema()
    {
        if (_sincronizarConDelfosUsuarios == null)
            return;

        _detenerHiloSincronizacionConDelfosUsuarios = true;
        _sincronizarConDelfosUsuarios.Abort();
    }
    private static void ActualizarUsuario(WSDelfos.Chrono_Usuario pUsuario)
    {   
        //Obtengo el registro de chrono, si no existe, devuelve null
        CA2Usuario _usuario = CA2Usuario.ObtenerPorUsuarioID(pUsuario.Login);

        //Si no existe, creo uno nuevo
        if (_usuario == null)
            _usuario = new CA2Usuario();
        
        // tengo que verificar si usuairo o contraseña son nulos, tengo que crear un error o alerta. 
        //SON ABLOGATORIOS

        // Atualizo los valores
        if(pUsuario.UsuaApe != null)
            _usuario.Apellido = pUsuario.UsuaApe;
        if (pUsuario.UsuaCelular != null)
            _usuario.Celular = pUsuario.UsuaCelular;
        _usuario.DocumentoNumero = "";
        _usuario.DocumentoTipo = CA2Parametros.TiposDeDocumento.DNI.ToString();
        if (pUsuario.Domicilio != null)
            _usuario.Domicilio = pUsuario.Domicilio;
        _usuario.Email = pUsuario.Login + "@noasignado.com";
        _usuario.FechaNacimiento = CA2Parametros.FechaMinima;
        if (pUsuario.Localidad != null)
            _usuario.Localidad = pUsuario.Localidad;
        if (pUsuario.UsuaNombre != null)
            _usuario.Nombre = pUsuario.UsuaNombre;
        if (pUsuario.Pais != null)
            _usuario.Pais = pUsuario.Pais;
        if (pUsuario.Provincia != null)
            _usuario.Provincia = pUsuario.Provincia;
        if (pUsuario.UsuaTele != null)
            _usuario.Telefono = pUsuario.UsuaTele;
        _usuario.UsuarioId = pUsuario.Login;
        
        //Genero la contrasena yo, ya que puedo recibir una que no sirva
        //_usuario.Contrasena = pUsuario.Password;
        _usuario.Contrasena = RC.ControlAcceso.ObjetosNegocio.Utiles.Utiles.CreateRandomPassword(10);
        
        //validar el tipo de documento
        // DESCOMENTAR LO DE ABAJOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO, arriba esta asignando el tipo DNI
        //_usuario.DocumentoTipo = CA2Parametros.TipoDocumentoCorrecto(pUsuario.TipoDocumento);

        //VALIDACIONES....... AGREGAR QUE EMAIL ES OBLIGATORIO
        if (_usuario.DocumentoTipo == "")
        {// si hay alguna alerta la genero por el método especificado para que aparezca despues.
            CA2Alerta.GenerarAlerta(DateTime.Now, CA2Alerta.AlertaOrigen.Sincronizacion_WebService, "Usuario: " + pUsuario.Login + ". El tipo de documento no es válido, permitidos: [DNI|CEDULA|PASAPORTE|LE].", CA2Alerta.AlertaImportancia.Media);
            return;
        }

        //Actualizo o inserto según sea el caso
        if (_usuario.ID <= 0)
            _usuario.Insertar();
        else
        {
            _usuario.RolesAsignados = _usuario.RolesAsignados;
            _usuario.Actualizar();
        }

        if (_usuario.ID <= 0)
            CA2Usuario.SeguridadBloquearUsuario(pUsuario.Login);
    }
    #endregion

    #region Métodos para sincronización con Delfos  de empleados (Personal en Chrono)
    private static Thread _sincronizarConDelfos;
    static volatile bool _detenerHiloSincronizacionConDelfos = false;
    /// <summary>
    /// Inicia el proceso de sincronización con Delfos
    /// </summary>
    private static void IniciarHiloSincronizacionConDelfosEmpleados()
    {
        if (CA2Parametros.EsModuloDeDelfos == false)
            return;

        if (CA2Parametros.SincronizacionDelfosActiva == false)
            return;

        // si esta activo el hilo, lo detengo si esta
        DetenerHilosincronizacionConDelfos();

        _sincronizarConDelfos = new Thread(SincronizarPersonal);
        _sincronizarConDelfos.Start();
        _detenerHiloSincronizacionConDelfos = false;
    }
    private static void SincronizarPersonal()
    {
        do
        {
            ForzarSincronizado(); // esta en otro metodo ya que puede ser llamado para sincronizar cuando se desee

            Thread.Sleep(300000); //5 min

        } while (_detenerHiloSincronizacionConDelfos == false);
    }
    /// <summary>
    /// Realiza una sincronización de los empleados(personal) del sistema.
    /// </summary>
    private static void ForzarSincronizado()
    {
        try
        {
            WSDelfos.WebServiceDelfos ws = new WSDelfos.WebServiceDelfos();

            WSDelfos.Chrono_Vendedor[] _vendedores = ws.getVendedorALL(CA2Parametros.ClaveWebServiceDelfos);

            //List<Chrono_Vendedor> _vendedores = new List<Chrono_Vendedor>();

            //_vendedores = ObtenerLoteDePruebaVendedores;

            if ((_vendedores != null)
                && (_vendedores.Length > 0))
            {
                foreach (WSDelfos.Chrono_Vendedor _vendedor in _vendedores)
                    ActualizarPersonal(_vendedor);
            }
        }
        catch(Exception e)
        {
        }
    }
    public static bool UsuarioPidioLogin(string pUsuarioId)
    {
        try
        {
            WSLoginExterno.LoginService ws = new WSLoginExterno.LoginService();
                //.WebServiceDelfos ws = new WSDelfos.WebServiceDelfos();

            return ws.LoginSistemaExterno(pUsuarioId);
            //return ws.UsuarioPidioLogin(CA2Parametros.ClaveWebServiceDelfos, pUsuarioId);

            //return true;
        }
        catch
        {
            return false;
        }
    }
    /// <summary>
    /// Detiene el hilo de impresion de tickets
    /// </summary>
    public static void DetenerHilosincronizacionConDelfos()
    {
        if (_sincronizarConDelfos == null)
            return;

        _detenerHiloSincronizacionConDelfos = true;
        _sincronizarConDelfos.Abort();
    }
    private static void ActualizarPersonal(WSDelfos.Chrono_Vendedor pVendedor)
    {
        //Obtengo el registro de chrono, si no existe, devuelve null
        CA2Personal _personal = CA2Personal.ObtenerPersonalPorNumeroDeLegajo(pVendedor.NumeroDeLegajo);

        //Si no existe, creo uno nuevo
        if (_personal == null)
            _personal = new CA2Personal();

        // Atualizo los valores
        if (pVendedor.Activo == 1)
            _personal.Activo = false;
        else
            _personal.Activo = true;
        
        if(pVendedor.Apellido != null)
            _personal.Apellido = pVendedor.Apellido;
        if (pVendedor.Celular != null)
            _personal.Celular = pVendedor.Celular;
        if (pVendedor.Cuil != null)
            _personal.CUIL = pVendedor.Cuil;
        if (pVendedor.Direccion != null)
            _personal.Direccion = pVendedor.Direccion;
        if (pVendedor.Documento != null)
            _personal.DocumentoNumero = pVendedor.Documento;
        else
            _personal.DocumentoNumero = "0";

        if (pVendedor.FechaNacimiento.HasValue == true)
            _personal.FechaNacimiento = pVendedor.FechaNacimiento.Value;
        else
            _personal.FechaNacimiento = CA2Parametros.FechaMinima;

        if (pVendedor.Localidad != null)
            _personal.Localidad = pVendedor.Localidad;
        if (pVendedor.Nombre != null)
            _personal.Nombre = pVendedor.Nombre;
        if (pVendedor.NumeroDeLegajo != null)
            _personal.NumeroLegajo = pVendedor.NumeroDeLegajo;
        if (_personal.NumeroTarjeta < 0)
            _personal.NumeroTarjeta = 0; // tarjeta 0 es sin asignar

        if (pVendedor.Pais != null)
            _personal.Pais = pVendedor.Pais;
        if (pVendedor.Provincia != null)
            _personal.Provincia = pVendedor.Provincia;
        if (pVendedor.Telefono != null)
            _personal.Telefono = pVendedor.Telefono;

        //validar el tipo de documento
        _personal.TipoDocumento = CA2Parametros.TipoDocumentoCorrecto(pVendedor.TipoDocumento);

        //VALIDACIONES
        if (_personal.TipoDocumento == "")
        {
            CA2Alerta.GenerarAlerta(DateTime.Now, CA2Alerta.AlertaOrigen.Sincronizacion_WebService, "Legajo: " + pVendedor.NumeroDeLegajo.ToString() + ". El tipo de documento no es válido, permitidos: [DNI|CEDULA|PASAPORTE|LE].", CA2Alerta.AlertaImportancia.Media);
            return;
        }

        //Actualizo o inserto según sea el caso
        if (_personal.IdPersonal <= 0)
            _personal.Insertar();
        else
            _personal.Actualizar();
    }
    #endregion

    #region Importar marcas de sensor biométrico
    private static Thread _importarMarcasBiometrico;
    static volatile bool _detenerHiloImportarMarcasBiometrico = false;
    /// <summary>
    /// Inicia el proceso de sincronización de marcas
    /// </summary>
    private static void IniciarHiloImportacionDeMarcas()
    {
        if (CA2Parametros.EsModuloDeDelfos == false)
            return;

        //if (CA2Parametros.SincronizacionDelfosActiva == false)
        //    return;

        // si esta activo el hilo, lo detengo si esta
        DetenerHiloImportacionMarcas();

        _importarMarcasBiometrico = new Thread(ImportarMarcas);
        _importarMarcasBiometrico.Start();
        _detenerHiloImportarMarcasBiometrico = false;
    }
    private static void ImportarMarcas()
    {
        do
        {
            RealizarImportacionDeMarcas(); // esta en otro metodo ya que puede ser llamado para sincronizar cuando se desee

            Thread.Sleep(300000); //5 min

        } while (_detenerHiloImportarMarcasBiometrico == false);
    }
    /// <summary>
    /// Detiene el hilo de impresion de tickets
    /// </summary>
    public static void DetenerHiloImportacionMarcas()
    {
        if (_importarMarcasBiometrico == null)
            return;

        _detenerHiloImportarMarcasBiometrico = true;
        _importarMarcasBiometrico.Abort();
    }
    /// <summary>
    /// Realiza una sincronización de los empleados(personal) del sistema.
    /// </summary>
    private static void RealizarImportacionDeMarcas()
    {
        try
        {
            CA2HistoricoMarca.ImportarMarcasDesdeInformeUsuario();
        }
        catch(Exception e)
        {
            CA2Alerta.GenerarAlerta(DateTime.Now, CA2Alerta.AlertaOrigen.Importacion_de_marcas, "Error en el proceso de importación de marcas", CA2Alerta.AlertaImportancia.Media);
        }
    }
    #endregion

    #region Generación de datos de prueba
    private static List<Chrono_Vendedor> ObtenerLoteDePruebaVendedores
    {
        get
        {
            List<Chrono_Vendedor> _cvs = new List<Chrono_Vendedor>();

            Chrono_Vendedor _cv = new Chrono_Vendedor();
            _cv.Activo = 0;
            _cv.Apellido = "Apellido1";
            _cv.Celular = "Celu1";
            _cv.Cuil = "CUIL1";
            _cv.Direccion = "Direecion1";
            _cv.Documento = "123345";
            _cv.FechaNacimiento = DateTime.Parse("01/01/1980");
            _cv.Localidad = "Localidad 1";
            _cv.Nombre = "Nombre1";
            _cv.NumeroDeLegajo = 9000;
            _cv.Pais = "Pais1";
            _cv.Provincia = "Provincia1";
            _cv.Telefono = "Telefono1";
            _cv.TipoDocumento = "DNI";
            _cvs.Add(_cv);

            _cv = new Chrono_Vendedor();
            _cv.Activo = 0;
            _cv.Apellido = "Apellido2";
            _cv.Celular = "Celu2";
            _cv.Cuil = "CUIL2";
            _cv.Direccion = "Direecion2";
            _cv.Documento = "12123345";
            _cv.FechaNacimiento = DateTime.Parse("01/01/1980");
            _cv.Localidad = "Localidad 2";
            _cv.Nombre = "Nombre2";
            _cv.NumeroDeLegajo = 9001;
            _cv.Pais = "Pais2";
            _cv.Provincia = "Provincia2";
            _cv.Telefono = "Telefono2";
            _cv.TipoDocumento = "DNI";
            _cvs.Add(_cv);

            _cv = new Chrono_Vendedor();
            _cv.Activo = 0;
            _cv.Apellido = "Apellido3";
            _cv.Celular = "Celu3";
            _cv.Cuil = "CUIL3";
            _cv.Direccion = "Direecion3";
            _cv.Documento = "123123";
            _cv.FechaNacimiento = DateTime.Parse("01/01/1980");
            _cv.Localidad = "Localidad 3";
            _cv.Nombre = "Nombre3";
            _cv.NumeroDeLegajo = 9002;
            _cv.Pais = "Pais3";
            _cv.Provincia = "Provincia3";
            _cv.Telefono = "Telefono3";
            _cv.TipoDocumento = "DNI";
            _cvs.Add(_cv);

            return _cvs;
        }
    }
    private static List<Chrono_Usuario> ObtenerLoteDePruebaUsuarios
    {
        get
        {
            List<Chrono_Usuario> _cus = new List<Chrono_Usuario>();

            Chrono_Usuario _cu = new Chrono_Usuario();
            _cu.ID = 0;
            _cu.LOGIN = "usuario1";
            _cu.PASSWORD = "asdf123";
            _cu.UsaChrono = true;
            _cus.Add(_cu);

            _cu = new Chrono_Usuario();
            _cu.ID = 1;
            _cu.LOGIN = "usuario2";
            _cu.PASSWORD = "asdf123";
            _cu.UsaChrono = true;
            _cus.Add(_cu);

            _cu = new Chrono_Usuario();
            _cu.ID = 2;
            _cu.LOGIN = "usuario3";
            _cu.PASSWORD = "asdf123";
            _cu.UsaChrono = false;
            _cus.Add(_cu);

            _cu = new Chrono_Usuario();
            _cu.ID = 3;
            _cu.LOGIN = "usuario4";
            _cu.PASSWORD = "asdf123";
            _cu.UsaChrono = true;
            _cus.Add(_cu);

            return _cus;
        }
    }
    #endregion

}
#region Clases para imprimir tickets
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//****************************************************************************************************************//
//                    CLASE PARA IMPRIMIR TICKETS
public class Ticket
{
    ArrayList headerLines = new ArrayList();
    ArrayList subHeaderLines = new ArrayList();
    ArrayList items = new ArrayList();
    ArrayList totales = new ArrayList();
    ArrayList footerLines = new ArrayList();
    private Image headerImage = null;

    int count = 0;

    int maxChar = 35;
    int maxCharDescription = 20;

    int imageHeight = 0;

    float leftMargin = 0;
    float topMargin = 3;

    string fontName = "Lucida Console";
    int fontSize = 9;

    Font printFont = null;
    SolidBrush myBrush = new SolidBrush(Color.Black);

    Graphics gfx = null;

    string line = null;

    public Ticket()
    {

    }

    public Image HeaderImage
    {
        get { return headerImage; }
        set { if (headerImage != value) headerImage = value; }
    }

    public int MaxChar
    {
        get { return maxChar; }
        set { if (value != maxChar) maxChar = value; }
    }

    public int MaxCharDescription
    {
        get { return maxCharDescription; }
        set { if (value != maxCharDescription) maxCharDescription = value; }
    }

    public int FontSize
    {
        get { return fontSize; }
        set { if (value != fontSize) fontSize = value; }
    }

    public string FontName
    {
        get { return fontName; }
        set { if (value != fontName) fontName = value; }
    }

    public void AddHeaderLine(string line)
    {
        headerLines.Add(line);
    }

    public void AddSubHeaderLine(string line)
    {
        subHeaderLines.Add(line);
    }

    public void AddItem(string cantidad, string item, string price)
    {
        OrderItem newItem = new OrderItem('?');
        items.Add(newItem.GenerateItem(cantidad, item, price));
    }

    public void AddTotal(string name, string price)
    {
        OrderTotal newTotal = new OrderTotal('?');
        totales.Add(newTotal.GenerateTotal(name, price));
    }

    public void AddFooterLine(string line)
    {
        footerLines.Add(line);
    }

    private string AlignRightText(int lenght)
    {
        string espacios = "";
        int spaces = maxChar - lenght;
        for (int x = 0; x < spaces; x++)
            espacios += " ";
        return espacios;
    }

    private string DottedLine()
    {
        string dotted = "";
        for (int x = 0; x < maxChar; x++)
            dotted += "_";
        return dotted;
    }
    public void AgregarLineaEnHeader()
    {
        string dotted = "";
        for (int x = 0; x < maxChar; x++)
            dotted += "_";
        AddHeaderLine(dotted);
    }
    public bool PrinterExists(string impresora)
    {
        foreach (String strPrinter in PrinterSettings.InstalledPrinters)
        {
            if (impresora == strPrinter)
                return true;
        }
        return false;
    }

    public void PrintTicket(string impresora)
    {
        printFont = new Font(fontName, fontSize, FontStyle.Regular);
        PrintDocument pr = new PrintDocument();
        pr.PrinterSettings.PrinterName = impresora;
        pr.PrintPage += new PrintPageEventHandler(pr_PrintPage);
        if (pr.PrinterSettings.IsValid == false)
            return;
        pr.Print();
    }

    private void pr_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
    {
        e.Graphics.PageUnit = GraphicsUnit.Millimeter;
        gfx = e.Graphics;

        DrawImage();
        DrawHeader();
        DrawSubHeader();
        //DrawItems();
        //DrawTotales();
        DrawFooter();

        if (headerImage != null)
        {
            HeaderImage.Dispose();
            headerImage.Dispose();
        }
    }

    private float YPosition()
    {
        return topMargin + (count * printFont.GetHeight(gfx) + imageHeight);
    }

    private void DrawImage()
    {
        if (headerImage != null)
        {
            try
            {
                gfx.DrawImage(headerImage, new Point((int)leftMargin, (int)YPosition()));
                double height = ((double)headerImage.Height / 58) * 15;
                imageHeight = (int)Math.Round(height) + 3;
            }
            catch (Exception)
            {
            }
        }
    }

    private void DrawHeader()
    {
        foreach (string header in headerLines)
        {
            if (header.Length > maxChar)
            {
                int currentChar = 0;
                int headerLenght = header.Length;

                while (headerLenght > maxChar)
                {
                    line = header.Substring(currentChar, maxChar);
                    gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                    count++;
                    currentChar += maxChar;
                    headerLenght -= maxChar;
                }
                line = header;
                gfx.DrawString(line.Substring(currentChar, line.Length - currentChar), printFont, myBrush, leftMargin, YPosition(), new StringFormat());
                count++;
            }
            else
            {
                line = header;
                gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                count++;
            }
        }
        DrawEspacio();
    }

    private void DrawSubHeader()
    {
        foreach (string subHeader in subHeaderLines)
        {
            if (subHeader.Length > maxChar)
            {
                int currentChar = 0;
                int subHeaderLenght = subHeader.Length;

                while (subHeaderLenght > maxChar)
                {
                    line = subHeader;
                    gfx.DrawString(line.Substring(currentChar, maxChar), printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                    count++;
                    currentChar += maxChar;
                    subHeaderLenght -= maxChar;
                }
                line = subHeader;
                gfx.DrawString(line.Substring(currentChar, line.Length - currentChar), printFont, myBrush, leftMargin, YPosition(), new StringFormat());
                count++;
            }
            else
            {
                line = subHeader;

                gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                count++;

                line = DottedLine();

                gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                count++;
            }
        }
        DrawEspacio();
    }

    private void DrawItems()
    {
        OrderItem ordIt = new OrderItem('?');

        gfx.DrawString("CANT  DESCRIPCION           IMPORTE", printFont, myBrush, leftMargin, YPosition(), new StringFormat());

        count++;
        DrawEspacio();

        foreach (string item in items)
        {
            line = ordIt.GetItemCantidad(item);

            gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

            line = ordIt.GetItemPrice(item);
            line = AlignRightText(line.Length) + line;

            gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

            string name = ordIt.GetItemName(item);

            leftMargin = 0;
            if (name.Length > maxCharDescription)
            {
                int currentChar = 0;
                int itemLenght = name.Length;

                while (itemLenght > maxCharDescription)
                {
                    line = ordIt.GetItemName(item);
                    gfx.DrawString("      " + line.Substring(currentChar, maxCharDescription), printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                    count++;
                    currentChar += maxCharDescription;
                    itemLenght -= maxCharDescription;
                }

                line = ordIt.GetItemName(item);
                gfx.DrawString("      " + line.Substring(currentChar, line.Length - currentChar), printFont, myBrush, leftMargin, YPosition(), new StringFormat());
                count++;
            }
            else
            {
                gfx.DrawString("      " + ordIt.GetItemName(item), printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                count++;
            }
        }

        leftMargin = 0;
        DrawEspacio();
        line = DottedLine();

        gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

        count++;
        DrawEspacio();
    }

    private void DrawTotales()
    {
        OrderTotal ordTot = new OrderTotal('?');

        foreach (string total in totales)
        {
            line = ordTot.GetTotalCantidad(total);
            line = AlignRightText(line.Length) + line;

            gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());
            leftMargin = 0;

            line = "      " + ordTot.GetTotalName(total);
            gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());
            count++;
        }
        leftMargin = 0;
        DrawEspacio();
        DrawEspacio();
    }

    private void DrawFooter()
    {
        foreach (string footer in footerLines)
        {
            if (footer.Length > maxChar)
            {
                int currentChar = 0;
                int footerLenght = footer.Length;

                while (footerLenght > maxChar)
                {
                    line = footer;
                    gfx.DrawString(line.Substring(currentChar, maxChar), printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                    count++;
                    currentChar += maxChar;
                    footerLenght -= maxChar;
                }
                line = footer;
                gfx.DrawString(line.Substring(currentChar, line.Length - currentChar), printFont, myBrush, leftMargin, YPosition(), new StringFormat());
                count++;
            }
            else
            {
                line = footer;
                gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

                count++;
            }
        }
        leftMargin = 0;
        DrawEspacio();
    }

    private void DrawEspacio()
    {
        line = "";

        gfx.DrawString(line, printFont, myBrush, leftMargin, YPosition(), new StringFormat());

        count++;
    }
}

public class OrderItem
{
    char[] delimitador = new char[] { '?' };

    public OrderItem(char delimit)
    {
        delimitador = new char[] { delimit };
    }

    public string GetItemCantidad(string orderItem)
    {
        string[] delimitado = orderItem.Split(delimitador);
        return delimitado[0];
    }

    public string GetItemName(string orderItem)
    {
        string[] delimitado = orderItem.Split(delimitador);
        return delimitado[1];
    }

    public string GetItemPrice(string orderItem)
    {
        string[] delimitado = orderItem.Split(delimitador);
        return delimitado[2];
    }

    public string GenerateItem(string cantidad, string itemName, string price)
    {
        return cantidad + delimitador[0] + itemName + delimitador[0] + price;
    }
}

public class OrderTotal
{
    char[] delimitador = new char[] { '?' };

    public OrderTotal(char delimit)
    {
        delimitador = new char[] { delimit };
    }

    public string GetTotalName(string totalItem)
    {
        string[] delimitado = totalItem.Split(delimitador);
        return delimitado[0];
    }

    public string GetTotalCantidad(string totalItem)
    {
        string[] delimitado = totalItem.Split(delimitador);
        return delimitado[1];
    }

    public string GenerateTotal(string totalName, string price)
    {
        return totalName + delimitador[0] + price;
    }
}
#region Impresoras
///Clase para chequear las impresoras
///

#endregion
#endregion